/**
 * 统一存储服务
 * 封装 uni.setStorage 和 uni.getStorage，提供同步和异步两种方式
 * 支持加密存储，确保敏感数据安全
 */

import { encryptData, decryptData } from './crypto.js';

const StorageKeys = {
	TAGS: 'password_tags',           // 标签列表
	ACCOUNTS: 'password_accounts',   // 账号列表
	TAG_COUNTER: 'password_tag_counter',  // 标签ID计数器
	ACCOUNT_COUNTER: 'password_account_counter',  // 账号ID计数器
	ENCRYPTION_ENABLED: 'password_encryption_enabled'  // 加密开关
};

// 需要加密的存储键
const ENCRYPTED_KEYS = [
	StorageKeys.TAGS,
	StorageKeys.ACCOUNTS
];

/**
 * 同步设置存储（自动加密敏感数据）
 * @param {string} key 存储键
 * @param {any} value 存储值
 * @param {boolean} forceEncrypt 强制加密（可选）
 */
export function setStorageSync(key, value, forceEncrypt = false) {
	try {
		let dataToStore = value;
		
		// 检查是否需要加密
		const shouldEncrypt = forceEncrypt || ENCRYPTED_KEYS.includes(key);
		
		if (shouldEncrypt && value !== null && value !== undefined) {
			// 将数据转换为 JSON 字符串再加密
			const jsonString = JSON.stringify(value);
			dataToStore = encryptData(jsonString);
			
			// 标记该键已启用加密
			if (!forceEncrypt) {
				uni.setStorageSync(StorageKeys.ENCRYPTION_ENABLED + '_' + key, true);
			}
		}
		
		uni.setStorageSync(key, dataToStore);
		return true;
	} catch (e) {
		console.error('存储失败:', e);
		return false;
	}
}

/**
 * 同步获取存储（自动解密数据）
 * @param {string} key 存储键
 * @param {any} defaultValue 默认值
 * @returns {any} 存储的值（已解密）
 */
export function getStorageSync(key, defaultValue = null) {
	try {
		const value = uni.getStorageSync(key);
		
		if (value === '' || value === null || value === undefined) {
			return defaultValue;
		}
		
		// 如果值不是字符串，直接返回（可能是旧数据直接存储的对象/数组）
		if (typeof value !== 'string') {
			// 旧数据可能是直接存储的对象或数组
			if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
				return value;
			}
			return value;
		}
		
		// 检查是否为加密数据（仅字符串类型且以 ENC: 开头）
		if (value.startsWith('ENC:')) {
			try {
				// 解密数据
				const decryptedString = decryptData(value);
				
				// 验证解密后的字符串是否为有效的 JSON
				if (!decryptedString || typeof decryptedString !== 'string') {
					console.warn('解密后数据无效，尝试返回原始值');
					// 尝试解析为旧数据格式
					try {
						return JSON.parse(value); // 如果原始值本身就是 JSON 字符串
					} catch {
						return value;
					}
				}
				
				// 尝试解析 JSON（先清理可能的无效字符）
				try {
					// 清理字符串：移除可能的无效字符和空白
					let cleanString = decryptedString.trim();
					
					// 如果是 JSON 数组或对象，尝试提取有效部分
					if (cleanString.startsWith('[')) {
						// 找到最后一个匹配的 ']'
						const lastBracket = cleanString.lastIndexOf(']');
						if (lastBracket > 0) {
							cleanString = cleanString.substring(0, lastBracket + 1);
						}
					} else if (cleanString.startsWith('{')) {
						// 找到最后一个匹配的 '}'
						const lastBrace = cleanString.lastIndexOf('}');
						if (lastBrace > 0) {
							cleanString = cleanString.substring(0, lastBrace + 1);
						}
					}
					
					const parsed = JSON.parse(cleanString);
					// 验证解析结果
					if (parsed !== null && typeof parsed !== 'undefined') {
						return parsed;
					}
				} catch (jsonError) {
					// JSON 解析失败，可能是解密错误或数据损坏
					// 静默处理，不输出错误日志（避免控制台刷屏）
					// 尝试更宽松的解析：查找第一个完整的 JSON 对象/数组
					try {
						let cleanString = decryptedString.trim();
						
						// 尝试找到第一个有效的 JSON 结构
						if (cleanString.startsWith('[')) {
							let bracketCount = 0;
							let validEnd = -1;
							for (let i = 0; i < cleanString.length; i++) {
								if (cleanString[i] === '[') bracketCount++;
								if (cleanString[i] === ']') bracketCount--;
								if (bracketCount === 0 && i > 0) {
									validEnd = i;
									break;
								}
							}
							if (validEnd > 0) {
								cleanString = cleanString.substring(0, validEnd + 1);
								const parsed = JSON.parse(cleanString);
								if (parsed !== null) {
									return parsed;
								}
							}
						} else if (cleanString.startsWith('{')) {
							let braceCount = 0;
							let validEnd = -1;
							for (let i = 0; i < cleanString.length; i++) {
								if (cleanString[i] === '{') braceCount++;
								if (cleanString[i] === '}') braceCount--;
								if (braceCount === 0 && i > 0) {
									validEnd = i;
									break;
								}
							}
							if (validEnd > 0) {
								cleanString = cleanString.substring(0, validEnd + 1);
								const parsed = JSON.parse(cleanString);
								if (parsed !== null) {
									return parsed;
								}
							}
						}
					} catch {
						// 更宽松的解析也失败
					}
					
					// 如果所有解析都失败，尝试将原始值作为旧数据处理
					try {
						const oldParsed = JSON.parse(value);
						if (Array.isArray(oldParsed) || (typeof oldParsed === 'object' && oldParsed !== null)) {
							return oldParsed;
						}
					} catch {
						// 都失败了，返回原始值
					}
				}
				
				// 如果解密失败，返回原始值（兼容旧数据）
				return value;
			} catch (e) {
				console.warn('解密过程出错:', e.message);
				// 解密失败，尝试作为旧数据处理
				try {
					// 可能是旧的未加密 JSON 字符串
					if (value.startsWith('[') || value.startsWith('{')) {
						const parsed = JSON.parse(value);
						if (Array.isArray(parsed) || (typeof parsed === 'object' && parsed !== null)) {
							return parsed;
						}
					}
				} catch {
					// 解析也失败
				}
				return value;
			}
		}
		
		// 如果是旧的非加密 JSON 字符串数据（兼容旧数据）
		if (value.startsWith('[') || value.startsWith('{')) {
			try {
				const parsed = JSON.parse(value);
				// 如果是数组或对象，返回解析后的数据（可能是旧数据）
				if (Array.isArray(parsed) || (typeof parsed === 'object' && parsed !== null)) {
					return parsed;
				}
			} catch (e) {
				// 解析失败，返回原始值
			}
		}
		
		return value;
	} catch (e) {
		console.error('获取存储失败:', e);
		return defaultValue;
	}
}

/**
 * 异步设置存储（自动加密敏感数据）
 * @param {string} key 存储键
 * @param {any} value 存储值
 * @param {boolean} forceEncrypt 强制加密（可选）
 * @returns {Promise<boolean>}
 */
export function setStorage(key, value, forceEncrypt = false) {
	return new Promise((resolve, reject) => {
		try {
			let dataToStore = value;
			
			// 检查是否需要加密
			const shouldEncrypt = forceEncrypt || ENCRYPTED_KEYS.includes(key);
			
			if (shouldEncrypt && value !== null && value !== undefined) {
				// 将数据转换为 JSON 字符串再加密
				const jsonString = JSON.stringify(value);
				dataToStore = encryptData(jsonString);
			}
			
			uni.setStorage({
				key: key,
				data: dataToStore,
				success: () => resolve(true),
				fail: (err) => {
					console.error('存储失败:', err);
					reject(err);
				}
			});
		} catch (e) {
			console.error('加密存储失败:', e);
			reject(e);
		}
	});
}

/**
 * 异步获取存储（自动解密数据）
 * @param {string} key 存储键
 * @param {any} defaultValue 默认值
 * @returns {Promise<any>} 存储的值（已解密）
 */
export function getStorage(key, defaultValue = null) {
	return new Promise((resolve, reject) => {
		uni.getStorage({
			key: key,
			success: (res) => {
				const value = res.data;
				
				if (value === '' || value === null || value === undefined) {
					resolve(defaultValue);
					return;
				}
				
				// 如果值不是字符串，直接返回（可能是旧数据直接存储的对象/数组）
				if (typeof value !== 'string') {
					if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
						resolve(value);
						return;
					}
					resolve(value);
					return;
				}
				
				// 检查是否为加密数据（仅字符串类型且以 ENC: 开头）
				if (value.startsWith('ENC:')) {
					try {
						// 解密数据
						const decryptedString = decryptData(value);
						
						// 验证解密后的字符串
						if (!decryptedString || typeof decryptedString !== 'string') {
							console.warn('解密后数据无效');
							// 尝试作为旧数据处理
							try {
								const oldParsed = JSON.parse(value);
								if (Array.isArray(oldParsed) || (typeof oldParsed === 'object' && oldParsed !== null)) {
									resolve(oldParsed);
									return;
								}
							} catch {
								resolve(value);
								return;
							}
						}
						
						// 解析 JSON（先清理可能的无效字符）
						try {
							let cleanString = decryptedString.trim();
							
							// 清理字符串：提取有效的 JSON 部分
							if (cleanString.startsWith('[')) {
								const lastBracket = cleanString.lastIndexOf(']');
								if (lastBracket > 0) {
									cleanString = cleanString.substring(0, lastBracket + 1);
								}
							} else if (cleanString.startsWith('{')) {
								const lastBrace = cleanString.lastIndexOf('}');
								if (lastBrace > 0) {
									cleanString = cleanString.substring(0, lastBrace + 1);
								}
							}
							
							const parsed = JSON.parse(cleanString);
							if (parsed !== null && typeof parsed !== 'undefined') {
								resolve(parsed);
								return;
							}
						} catch (jsonError) {
							// 静默处理 JSON 解析错误，尝试更宽松的解析
							try {
								let cleanString = decryptedString.trim();
								
								if (cleanString.startsWith('[')) {
									let bracketCount = 0;
									let validEnd = -1;
									for (let i = 0; i < cleanString.length; i++) {
										if (cleanString[i] === '[') bracketCount++;
										if (cleanString[i] === ']') bracketCount--;
										if (bracketCount === 0 && i > 0) {
											validEnd = i;
											break;
										}
									}
									if (validEnd > 0) {
										cleanString = cleanString.substring(0, validEnd + 1);
										const parsed = JSON.parse(cleanString);
										if (parsed !== null) {
											resolve(parsed);
											return;
										}
									}
								} else if (cleanString.startsWith('{')) {
									let braceCount = 0;
									let validEnd = -1;
									for (let i = 0; i < cleanString.length; i++) {
										if (cleanString[i] === '{') braceCount++;
										if (cleanString[i] === '}') braceCount--;
										if (braceCount === 0 && i > 0) {
											validEnd = i;
											break;
										}
									}
									if (validEnd > 0) {
										cleanString = cleanString.substring(0, validEnd + 1);
										const parsed = JSON.parse(cleanString);
										if (parsed !== null) {
											resolve(parsed);
											return;
										}
									}
								}
							} catch {
								// 更宽松的解析也失败
							}
							
							// 尝试将原始值作为旧数据
							try {
								const oldParsed = JSON.parse(value);
								if (Array.isArray(oldParsed) || (typeof oldParsed === 'object' && oldParsed !== null)) {
									resolve(oldParsed);
									return;
								}
							} catch {
								// 都失败了
							}
						}
						
						resolve(value);
					} catch (e) {
						console.warn('解密过程出错:', e.message);
						// 尝试作为旧数据处理
						try {
							if (value.startsWith('[') || value.startsWith('{')) {
								const parsed = JSON.parse(value);
								if (Array.isArray(parsed) || (typeof parsed === 'object' && parsed !== null)) {
									resolve(parsed);
									return;
								}
							}
						} catch {
							// 解析也失败
						}
						resolve(value);
					}
				} else if (value.startsWith('[') || value.startsWith('{')) {
					// 兼容旧的非加密 JSON 字符串数据
					try {
						const parsed = JSON.parse(value);
						if (Array.isArray(parsed) || (typeof parsed === 'object' && parsed !== null)) {
							resolve(parsed);
						} else {
							resolve(value);
						}
					} catch (e) {
						resolve(value);
					}
				} else {
					resolve(value);
				}
			},
			fail: (err) => {
				// 如果key不存在，返回默认值而不是reject
				if (err.errMsg && err.errMsg.includes('not found')) {
					resolve(defaultValue);
				} else {
					console.error('获取存储失败:', err);
					reject(err);
				}
			}
		});
	});
}

/**
 * 删除存储
 * @param {string} key 存储键
 */
export function removeStorage(key) {
	try {
		uni.removeStorageSync(key);
		return true;
	} catch (e) {
		console.error('删除存储失败:', e);
		return false;
	}
}

/**
 * 清空所有存储
 */
export function clearStorage() {
	try {
		uni.clearStorageSync();
		return true;
	} catch (e) {
		console.error('清空存储失败:', e);
		return false;
	}
}

export { StorageKeys };
